/**
 * 带缓存管理的图片预览功能
 * @param {string} url - 图片原始URL
 * @param {boolean} [forceDownload=false] - 是否强制重新下载
 */
export default async function previewImageWithCache(url, forceDownload = false) {
  try {
    // 显示加载状态
    // uni.showLoading({ title: '加载中...', mask: true });
    
    // 检查是否需要跳过缓存
    if (!forceDownload) {
      // 从缓存映射中查找
      const cacheMap = getImageCacheMap();
      const cacheKey = getCacheKey(url);
      const cached = cacheMap[cacheKey];
      
      if (cached) {
        // 检查缓存文件是否存在且有效
        const isValid = await verifyCachedFile(cached.filePath);
        if (isValid) {
          console.log('使用缓存图片:', cached.filePath);
          uni.hideLoading();
          return uni.previewImage({ urls: [cached.filePath] });
        } else {
          console.log('缓存文件无效，重新下载');
          // 从缓存映射中移除无效记录
          removeCacheEntry(cacheKey);
        }
      }
    }
    
    // 未缓存或需要重新下载
    console.log('开始下载图片:', url);
    
    // 检查网络状态（非WiFi环境提示）
    const isWiFi = await checkNetworkType();
    if (!isWiFi) {
      const shouldContinue = await showNetworkConfirm();
      if (!shouldContinue) {
        uni.hideLoading();
        return;
      }
    }
    
    // 执行下载
    const downloadRes = await downloadFileWithRetry(url);
    
    // 保存文件到本地缓存
    const saveRes = await saveFile(downloadRes.tempFilePath);
    
    // 更新缓存映射
    saveImageCacheMapping(url, saveRes.savedFilePath);
    
    // 清理旧缓存（超过100MB时）
    cleanUpOldCaches(1000);
    
    // 预览图片
    uni.hideLoading();
    return uni.previewImage({ urls: [saveRes.savedFilePath] });
    
  } catch (error) {
    console.error('图片预览失败:', error);
    uni.hideLoading();
    uni.showToast({
      title: '图片已过期',
      icon: 'none',
      duration: 2000
    });
  }
}

/**
 * 获取缓存映射
 */
function getImageCacheMap() {
  try {
    return uni.getStorageSync('imageCacheMap') || {};
  } catch (error) {
    console.error('读取缓存映射失败:', error);
    return {};
  }
}

/**
 * 生成缓存键（处理带参数的URL）
 */
function getCacheKey(url) {
  // 移除可能变化的参数（如时间戳、签名）
  const baseUrl = url.split('?')[0];
  // 可以考虑添加哈希处理，确保唯一性
  return baseUrl;
}

/**
 * 验证缓存文件是否有效
 */
async function verifyCachedFile(filePath) {
  try {
    // 检查文件是否存在
    await checkFileExists(filePath);
    
    // 可选：检查文件大小是否合理（防止不完整下载）
    const fileInfo = await getFileInfo(filePath);
    return fileInfo.size > 1024; // 假设文件至少1KB
  } catch (error) {
    console.error('验证缓存文件失败:', error);
    return false;
  }
}

/**
 * 检查文件是否存在
 */
function checkFileExists(filePath) {
  return new Promise((resolve, reject) => {
    uni.getFileInfo({
      filePath,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 获取文件信息
 */
function getFileInfo(filePath) {
  return new Promise((resolve, reject) => {
    uni.getFileInfo({
      filePath,
      success: (res) => resolve(res),
      fail: (err) => reject(err)
    });
  });
}

/**
 * 保存图片URL与本地路径的映射
 */
function saveImageCacheMapping(url, filePath) {
  try {
    const cacheMap = getImageCacheMap();
    const cacheKey = getCacheKey(url);
    
    cacheMap[cacheKey] = {
      filePath,
      originalUrl: url,
      timestamp: Date.now(),
      size: getFileSize(filePath) // 可选：记录文件大小用于清理
    };
    
    uni.setStorageSync('imageCacheMap', cacheMap);
    console.log('已更新缓存映射:', cacheKey);
  } catch (error) {
    console.error('保存缓存映射失败:', error);
  }
}

/**
 * 移除缓存条目
 */
function removeCacheEntry(cacheKey) {
  try {
    const cacheMap = getImageCacheMap();
    if (cacheMap[cacheKey]) {
      delete cacheMap[cacheKey];
      uni.setStorageSync('imageCacheMap', cacheMap);
      console.log('已移除无效缓存条目:', cacheKey);
    }
  } catch (error) {
    console.error('移除缓存条目失败:', error);
  }
}

/**
 * 带重试机制的文件下载
 */
function downloadFileWithRetry(url, maxRetries = 3) {
  return new Promise((resolve, reject) => {
    let retries = 0;
    
    function attemptDownload() {
      uni.downloadFile({
        url,
        success: (res) => {
          if (res.statusCode === 200) {
            resolve(res);
          } else {
            reject(new Error(`下载失败，状态码: ${res.statusCode}`));
          }
        },
        fail: (err) => {
          retries++;
          if (retries <= maxRetries) {
            console.log(`下载尝试 ${retries}/${maxRetries} 失败，正在重试...`);
            attemptDownload();
          } else {
            reject(new Error(`下载失败，已达到最大重试次数: ${err.errMsg}`));
          }
        }
      });
    }
    
    attemptDownload();
  });
}

/**
 * 保存临时文件到永久存储
 */
function saveFile(tempFilePath) {
  return new Promise((resolve, reject) => {
    uni.saveFile({
      tempFilePath,
      success: (res) => resolve(res),
      fail: (err) => reject(err)
    });
  });
}

/**
 * 检查网络类型
 */
function checkNetworkType() {
  return new Promise((resolve) => {
    uni.getNetworkType({
      success: (res) => {
        resolve(res.networkType === 'wifi');
      },
      fail: () => {
        // 默认允许下载
        resolve(true);
      }
    });
  });
}

/**
 * 显示非WiFi环境确认对话框
 */
function showNetworkConfirm() {
  return new Promise((resolve) => {
    uni.showModal({
      title: '网络提示',
      content: '当前非WiFi环境，下载图片可能产生流量费用，是否继续？',
      confirmText: '继续下载',
      cancelText: '取消',
      success: (res) => {
        resolve(res.confirm);
      },
      fail: () => {
        resolve(false);
      }
    });
  });
}

/**
 * 清理旧缓存
 */
async function cleanUpOldCaches(maxSizeMB = 100) {
  try {
    const savedFiles = await getSavedFiles();
    const cacheMap = getImageCacheMap();
    
    // 计算总大小（MB）
    const totalSize = savedFiles.reduce((sum, file) => sum + file.size, 0) / (1024 * 1024);
    
    if (totalSize <= maxSizeMB) {
      console.log(`缓存总大小: ${totalSize.toFixed(2)}MB，未超过限制(${maxSizeMB}MB)`);
      return;
    }
    
    console.log(`缓存总大小: ${totalSize.toFixed(2)}MB，开始清理...`);
    
    // 按时间排序（旧的在前）
    const sortedFiles = savedFiles.sort((a, b) => {
      const timeA = cacheMap[a.filePath]?.timestamp || 0;
      const timeB = cacheMap[b.filePath]?.timestamp || 0;
      return timeA - timeB;
    });
    
    // 删除旧文件直到空间足够
    let deletedSize = 0;
    const targetSize = maxSizeMB * 0.8; // 清理到目标大小
    
    for (const file of sortedFiles) {
      if ((totalSize - deletedSize) / (1024 * 1024) <= targetSize) {
        break;
      }
      
      try {
        await removeFile(file.filePath);
        deletedSize += file.size;
        
        // 从缓存映射中删除
        const cacheKeyToDelete = Object.keys(cacheMap).find(
          key => cacheMap[key].filePath === file.filePath
        );
        
        if (cacheKeyToDelete) {
          delete cacheMap[cacheKeyToDelete];
        }
        
        console.log(`已清理缓存文件: ${file.filePath}，大小: ${(file.size / (1024 * 1024)).toFixed(2)}MB`);
      } catch (error) {
        console.error('删除缓存文件失败:', error);
      }
    }
    
    // 更新缓存映射
    uni.setStorageSync('imageCacheMap', cacheMap);
    console.log(`缓存清理完成，释放空间: ${(deletedSize / (1024 * 1024)).toFixed(2)}MB`);
    
  } catch (error) {
    console.error('清理缓存失败:', error);
  }
}

/**
 * 获取所有已保存的文件
 */
function getSavedFiles() {
  return new Promise((resolve, reject) => {
    uni.getSavedFileList({
      success: (res) => resolve(res.fileList),
      fail: (err) => reject(err)
    });
  });
}

/**
 * 删除文件
 */
function removeFile(filePath) {
  return new Promise((resolve, reject) => {
    uni.removeSavedFile({
      filePath,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 获取文件大小（同步方法）
 */
function getFileSize(filePath) {
  try {
    const res = uni.getFileInfoSync({ filePath });
    return res.size;
  } catch (error) {
    return 0;
  }
}